const { app, BrowserWindow, Menu, shell, ipcMain } = require('electron');
const path = require('path');
const { spawn } = require('child_process');
const { PythonShell } = require('python-shell');

let mainWindow;
let backendProcess;

// 开发模式检测
const isDev = process.env.NODE_ENV === 'development';

function createWindow() {
  // 创建浏览器窗口
  mainWindow = new BrowserWindow({
    width: 1400,
    height: 900,
    minWidth: 1200,
    minHeight: 800,
    webPreferences: {
      nodeIntegration: false,
      contextIsolation: true,
      enableRemoteModule: false,
      preload: path.join(__dirname, 'preload.js'),
      webSecurity: false,  // 禁用web安全策略
      allowRunningInsecureContent: true  // 允许运行不安全内容
    },
    icon: path.resolve(__dirname, '../assets/icon.icns'),
    titleBarStyle: 'default',  // 使用默认标题栏
    show: false,  // 先不显示，等准备好后再显示
    center: true,  // 居中显示
    alwaysOnTop: false,  // 不总是在最前面
    skipTaskbar: false  // 在任务栏中显示
  });

  // 加载应用
  if (isDev) {
    // 开发模式：加载React开发服务器
    mainWindow.loadURL('http://localhost:3000');
    mainWindow.webContents.openDevTools();
  } else {
    // 生产模式：加载React应用
    mainWindow.loadFile(path.join(__dirname, '../frontend/build/index.html'));
    // 在生产模式下也打开开发者工具以便调试
    mainWindow.webContents.openDevTools();
  }

  // 窗口准备好后显示
  mainWindow.once('ready-to-show', () => {
    mainWindow.show();
    // 设置窗口标题
    mainWindow.setTitle('参数管理系统');
    // 最大化窗口
    mainWindow.maximize();
    // 强制设置图标
    mainWindow.setIcon(path.resolve(__dirname, '../assets/icon.icns'));
    // 确保窗口获得焦点
    mainWindow.focus();
  });

  // 当窗口被关闭时
  mainWindow.on('closed', () => {
    mainWindow = null;
  });

  // 处理外部链接
  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
    shell.openExternal(url);
    return { action: 'deny' };
  });
}

// 启动后端服务器
function startBackend() {
  return new Promise((resolve, reject) => {
    // 检测是否在打包后的应用中
    const isPackaged = app.isPackaged;
    let backendPath, scriptPath, pythonCommand;
    
    if (isPackaged) {
      // 打包后的应用，使用相对路径
      backendPath = path.join(process.resourcesPath, 'backend');
      scriptPath = path.join(backendPath, 'start_server_packaged.py');
      // 尝试使用系统Python
      pythonCommand = 'python3';
    } else {
      // 开发模式
      backendPath = path.join(__dirname, '../backend');
      scriptPath = path.join(backendPath, 'start_server_electron.py');
      pythonCommand = 'python3';
    }
    
    console.log('启动后端服务器:', scriptPath);
    console.log('是否打包应用:', isPackaged);
    
    // 先尝试杀死可能存在的后端进程
    const { exec } = require('child_process');
    exec('pkill -f "start_server_electron.py"', (error) => {
      // 忽略错误，继续启动
      console.log('清理可能存在的后端进程...');
      
      // 使用spawn启动Python进程
      backendProcess = spawn(pythonCommand, [scriptPath], {
        cwd: backendPath,
        stdio: ['pipe', 'pipe', 'pipe'],
        env: {
          ...process.env,
          PYTHONPATH: backendPath
        }
      });
      
      // 监听进程输出
      backendProcess.stdout.on('data', (data) => {
        console.log(`后端输出: ${data}`);
      });
      
      backendProcess.stderr.on('data', (data) => {
        console.error(`后端错误: ${data}`);
      });
      
      backendProcess.on('close', (code) => {
        console.log(`后端进程退出，代码: ${code}`);
        backendProcess = null;
      });
      
      backendProcess.on('error', (err) => {
        console.error('启动后端服务器失败:', err);
        // 如果python3失败，尝试python
        if (pythonCommand === 'python3') {
          console.log('尝试使用python命令...');
          backendProcess = spawn('python', [scriptPath], {
            cwd: backendPath,
            stdio: ['pipe', 'pipe', 'pipe'],
            env: {
              ...process.env,
              PYTHONPATH: backendPath
            }
          });
        } else {
          reject(err);
        }
      });
      
      // 等待服务器启动
      setTimeout(() => {
        console.log('后端服务器启动完成');
        resolve();
      }, 3000);
    });
  });
}

// 停止后端服务器
function stopBackend() {
  if (backendProcess) {
    backendProcess.kill();
    backendProcess = null;
  }
}

// 创建菜单
function createMenu() {
  const template = [
    {
      label: '文件',
      submenu: [
        {
          label: '新建项目',
          accelerator: 'CmdOrCtrl+N',
          click: () => {
            mainWindow.webContents.send('menu-new-project');
          }
        },
        {
          label: '导入项目',
          accelerator: 'CmdOrCtrl+I',
          click: () => {
            mainWindow.webContents.send('menu-import-project');
          }
        },
        { type: 'separator' },
        {
          label: '退出',
          accelerator: process.platform === 'darwin' ? 'Cmd+Q' : 'Ctrl+Q',
          click: () => {
            app.quit();
          }
        }
      ]
    },
    {
      label: '编辑',
      submenu: [
        { role: 'undo', label: '撤销' },
        { role: 'redo', label: '重做' },
        { type: 'separator' },
        { role: 'cut', label: '剪切' },
        { role: 'copy', label: '复制' },
        { role: 'paste', label: '粘贴' }
      ]
    },
    {
      label: '查看',
      submenu: [
        { role: 'reload', label: '重新加载' },
        { role: 'forceReload', label: '强制重新加载' },
        { role: 'toggleDevTools', label: '开发者工具' },
        { type: 'separator' },
        { role: 'resetZoom', label: '实际大小' },
        { role: 'zoomIn', label: '放大' },
        { role: 'zoomOut', label: '缩小' },
        { type: 'separator' },
        { role: 'togglefullscreen', label: '全屏' }
      ]
    },
    {
      label: '窗口',
      submenu: [
        { role: 'minimize', label: '最小化' },
        { role: 'close', label: '关闭' }
      ]
    },
    {
      label: '帮助',
      submenu: [
        {
          label: '关于参数管理系统',
          click: () => {
            mainWindow.webContents.send('menu-about');
          }
        }
      ]
    }
  ];

  if (process.platform === 'darwin') {
    template.unshift({
      label: app.getName(),
      submenu: [
        { role: 'about', label: '关于' },
        { type: 'separator' },
        { role: 'services', label: '服务' },
        { type: 'separator' },
        { role: 'hide', label: '隐藏' },
        { role: 'hideOthers', label: '隐藏其他' },
        { role: 'unhide', label: '显示全部' },
        { type: 'separator' },
        { role: 'quit', label: '退出' }
      ]
    });
  }

  const menu = Menu.buildFromTemplate(template);
  Menu.setApplicationMenu(menu);
}

// 应用准备就绪
app.whenReady().then(async () => {
  try {
    // 启动后端服务器
    console.log('正在启动后端服务器...');
    await startBackend();
    
    // 创建窗口
    createWindow();
    
    // 创建菜单
    createMenu();
    
    console.log('应用启动完成');
  } catch (error) {
    console.error('应用启动失败:', error);
    app.quit();
  }
});

// 当所有窗口都被关闭时
app.on('window-all-closed', () => {
  // 直接退出应用，不保持后台运行
  app.quit();
});

app.on('activate', () => {
  // 在 macOS 上，当单击 dock 图标并且没有其他窗口打开时，
  // 通常在应用程序中重新创建窗口。
  if (BrowserWindow.getAllWindows().length === 0) {
    createWindow();
  }
});

// 应用即将退出
app.on('before-quit', () => {
  stopBackend();
});

// IPC 处理程序
ipcMain.handle('get-app-version', () => {
  return app.getVersion();
});

ipcMain.handle('get-app-name', () => {
  return app.getName();
});

// 处理未捕获的异常
process.on('uncaughtException', (error) => {
  console.error('未捕获的异常:', error);
});

process.on('unhandledRejection', (reason, promise) => {
  console.error('未处理的Promise拒绝:', reason);
});
